// src/utils/streamFetch.js
/**
 * 移动端流式请求处理工具
 * 参考PC端的streamFetch实现，适配移动端Vue3环境
 */

import { getToken, clearToken } from './auth'
import { getXauatLoginToken } from './auth'

// SSE响应事件枚举
export const SseResponseEventEnum = {
  answer: 'answer',
  fastAnswer: 'fastAnswer',
  answerDone: 'answerDone',
  toolCall: 'toolCall',
  toolParams: 'toolParams',
  toolResponse: 'toolResponse',
  flowNodeStatus: 'flowNodeStatus',
  flowResponses: 'flowResponses',
  updateVariables: 'updateVariables',
  interactive: 'interactive',
  error: 'error'
};

/**
 * 获取错误文本
 * @param {any} err - 错误对象
 * @param {string} defaultText - 默认错误文本
 * @returns {string} 错误文本
 */
function getErrText(err, defaultText = '请求失败') {
  if (typeof err === 'string') return err;
  if (err?.message) return err.message;
  if (err?.msg) return err.msg;
  return defaultText;
}

// 添加重定向计数检查
const MAX_REDIRECTS = 3;
let redirectCount = 0;
let redirectTimestamps = [];

/**
 * 专门处理交互事件的函数
 * @param {Object} parseJson - 解析后的JSON数据
 * @param {Array} responseQueue - 响应队列
 * @returns {boolean} 是否处理了交互事件
 */
function handleInteractiveEvent(parseJson, responseQueue) {
  let interactiveData = null;

  // 检查顶层是否有interactive字段
  if (parseJson.interactive) {
    interactiveData = parseJson.interactive;
  }
  // 检查是否是直接的interactive对象（没有包装）
  else if (parseJson.type === 'userSelect' && parseJson.params) {
    interactiveData = parseJson;
  }
  // 检查event字段是否为interactive
  else if (parseJson.event === 'interactive' && parseJson.interactive) {
    interactiveData = parseJson.interactive;
  }
  // 检查是否是纯的交互对象
  else if (parseJson.type && parseJson.params &&
           (parseJson.type === 'userSelect' || parseJson.type === 'select')) {
    interactiveData = parseJson;
  }

  if (interactiveData) {
    console.log('检测到交互事件:', interactiveData);
    responseQueue.push({
      event: SseResponseEventEnum.interactive,
      interactive: interactiveData
    });
    return true;
  }

  return false;
}

/**
 * 流式请求处理函数
 * @param {Object} options - 请求选项
 * @param {string} options.url - 请求URL
 * @param {Object} options.data - 请求数据
 * @param {Function} options.onMessage - 消息处理回调
 * @param {AbortController} options.abortCtrl - 中止控制器
 * @returns {Promise<Object>} 响应结果
 */
export const streamFetch = ({
  url = '/huayun-ai/client/chat/completions',
  data,
  onMessage,
  abortCtrl
}) => {
   return new Promise((resolve, reject) => {
    // 添加 timeoutId 的定义
    let timeoutId;
    // 检查重定向次数，避免无限循环
    const now = Date.now();
    redirectTimestamps = redirectTimestamps.filter(ts => now - ts < 60000); // 1分钟内的重定向

    if (redirectCount > MAX_REDIRECTS || redirectTimestamps.length > MAX_REDIRECTS) {
      return reject({
        message: '重定向次数过多，请稍后再试'
      });
    }

    // 响应数据
    let responseText = '';
    let reasoningText = '';
    let isInteractive = false;
    let responseQueue = [];
    let errMsg = '';
    let responseData = [];
    let finished = false;
    let authRedirected = false; // 添加标志防止重复重定向

    /**
     * 完成处理
     */
    const finish = () => {
      if (errMsg) {
        return failedFinish();
      }
      return resolve({
        responseText,
        responseData,
        reasoningText,
        isInteractive
      });
    };

    /**
     * 失败处理
     * @param {any} err - 错误信息
     */
    const failedFinish = (err) => {
      finished = true;
      const message = err || errMsg ? getErrText(err, errMsg || '响应过程出现异常~') : '对话出现异常';

      reject({
        message: message,
        responseText,
        reasoningText
      });
    };

    /**
     * 判断是否为答案事件
     * @param {string} event - 事件类型
     * @returns {boolean}
     */
    const isAnswerEvent = (event) =>
      event === SseResponseEventEnum.answer || event === SseResponseEventEnum.fastAnswer;

    /**
     * 动画响应文本处理
     */
    function animateResponseText() {
      if (abortCtrl.signal.aborted) {
        responseQueue.forEach((item) => {
          onMessage(item);
          if (isAnswerEvent(item.event)) {
            responseText += item.text || '';
          }
        });
        return finish();
      }

      if (responseQueue.length > 0) {
        const fetchCount = Math.max(1, Math.round(responseQueue.length / 30));
        for (let i = 0; i < fetchCount; i++) {
          const item = responseQueue[i];
          if (item) {
            onMessage(item);
            if (isAnswerEvent(item.event)) {
              responseText += item.text || '';
            }
          }
        }
        responseQueue = responseQueue.slice(fetchCount);
      }

      if (finished && responseQueue.length === 0) {
        return finish();
      }

      requestAnimationFrame(animateResponseText);
    }

    // 开始动画
    animateResponseText();

    // 异步处理逻辑
    (async () => {
      try {
        // 自动完成变量
        const variables = data?.variables || {};
        const currentTime = new Date();
        variables.cTime = currentTime.toLocaleString('zh-CN', {
          year: 'numeric',
          month: '2-digit',
          day: '2-digit',
          hour: '2-digit',
          minute: '2-digit',
          second: '2-digit',
          hour12: false
        }).replace(/\//g, '-');

        // 获取认证token
        const token = getToken();

       // 正确示例（应该改为）
const fullUrl = url.startsWith('/huayun-ai')
  ? url  // 保持相对路径，让Nginx代理处理
  : url.startsWith('https://')
    ? url
    : `/huayun-ai${url.startsWith('/') ? url : '/' + url}`;
        console.log('构建的请求URL:', fullUrl); // 添加调试日志

        // 设置请求超时
        timeoutId = setTimeout(() => {
          reject({ message: '请求超时' });
        }, 30000); // 30秒超时

        // 构建请求数据，参考HomeView.vue中其他请求的headers格式
        const requestData = {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'Accept': 'application/json, text/plain, */*',
            'Referer': 'https://owner-b.xauat.edu.cn/',
            'Origin': 'https://owner-b.xauat.edu.cn'
          },
          signal: abortCtrl.signal,
          body: JSON.stringify({
            ...data,
            variables,
            detail: true,
            stream: true
          })
        };

        if (token) {
  let authHeader = token.startsWith('Bearer ') ? token : `Bearer ${token}`;

  // 检查是否有重复的 Bearer 前缀（调试用）
  if (authHeader.startsWith('Bearer Bearer ')) {
    console.warn('检测到重复的 Bearer 前缀，正在修复:', authHeader);
    authHeader = authHeader.replace('Bearer Bearer ', 'Bearer ');
    console.warn('修复后的 Authorization 头:', authHeader);
  }

  requestData.headers.Authorization = authHeader;
}

        // 发送请求
        const response = await fetch(fullUrl, requestData);

        clearTimeout(timeoutId);

        // 检查响应状态
          if (!response.ok) {
            // 处理认证失败
            if (response.status === 401 || response.status === 403) {
              // 只清除token，不重定向
              localStorage.removeItem('accessToken');
              throw new Error('AUTH_EXPIRED');
            } else if (response.status === 406) {
              // 只清除token，不重定向
              localStorage.removeItem('accessToken');
              throw new Error('PERMISSION_DENIED');
            } else {
              // 尝试解析错误响应
              let errorMsg;
              try {
                const errorData = await response.clone().json();
                errorMsg = errorData?.msg || `HTTP error! status: ${response.status}`;
              } catch {
                errorMsg = `HTTP error! status: ${response.status}`;
              }
              throw new Error(errorMsg);
            }
          }

        // 处理流式响应
        const reader = response.body.getReader();
        const decoder = new TextDecoder();
        let buffer = '';

        while (true) {
          try {
            const { done, value } = await reader.read();

            if (done) {
              finished = true;
              break;
            }

            if (value) {
              buffer += decoder.decode(value, { stream: true });
              const lines = buffer.split('\n');
              buffer = lines.pop() || '';

              for (const line of lines) {
                if (line.startsWith('data: ')) {
                  const data = line.substring(6);

                  if (data === '[DONE]') {
                    responseQueue.push({
                      event: SseResponseEventEnum.answerDone
                    });
                    continue;
                  }

                  // 解析JSON数据
                  let parseJson = {};
                  try {
                    parseJson = JSON.parse(data);
                  } catch (error) {
                    console.warn('JSON解析失败:', error, data);
                    continue;
                  }

                  // 使用独立函数处理交互事件
                  if (handleInteractiveEvent(parseJson, responseQueue)) {
                    continue;
                  }

                  // 处理不同类型的事件
                  // 检查是否包含AI回复内容（标准格式）
                  if (parseJson?.choices?.[0]?.delta?.content !== undefined) {
                    const text = parseJson.choices[0].delta.content || '';
                    reasoningText = parseJson.choices[0].delta.reasoning_content || '';

                    // 逐字符添加到队列，实现打字机效果
                    for (const char of text) {
                      responseQueue.push({
                        event: SseResponseEventEnum.answer,
                        text: char
                      });
                    }

                    if (reasoningText) {
                      for (const char of reasoningText) {
                        responseQueue.push({
                          event: SseResponseEventEnum.answer,
                          reasoningText: char
                        });
                      }
                    }
                  }
                  // 检查是否是flowResponses数据（包含流程节点信息的数组）
                  else if (Array.isArray(parseJson) && parseJson.length > 0 &&
                      parseJson[0].id && parseJson[0].nodeId && parseJson[0].moduleName) {
                    responseData = parseJson;
                    onMessage({
                      event: SseResponseEventEnum.flowResponses,
                      data: parseJson
                    });
                  }
                  // 检查是否有event字段且为flowResponses
                  else if (parseJson.event === 'flowResponses' && Array.isArray(parseJson.data)) {
                    responseData = parseJson.data;
                    onMessage({
                      event: SseResponseEventEnum.flowResponses,
                      data: parseJson.data
                    });
                  }
                  // 检查是否是包含流程节点信息的对象（单个节点）
                  else if (parseJson.id && parseJson.nodeId && parseJson.moduleName) {
                    if (!responseData) {
                      responseData = [];
                    }
                    if (Array.isArray(responseData)) {
                      responseData.push(parseJson);
                    }
                    onMessage({
                      event: SseResponseEventEnum.flowNodeStatus,
                      ...parseJson
                    });
                  }
                  // 处理其他可能的事件类型
                  else if (parseJson.event) {
                    const eventType = parseJson.event;
                    if (eventType === 'toolCall' || eventType === 'toolParams' || eventType === 'toolResponse') {
                      responseQueue.push({
                        event: eventType,
                        ...parseJson
                      });
                    } else if (eventType === 'flowNodeStatus') {
                      onMessage({
                        event: SseResponseEventEnum.flowNodeStatus,
                        ...parseJson
                      });
                    } else if (eventType === 'updateVariables') {
                      onMessage({
                        event: SseResponseEventEnum.updateVariables,
                        variables: parseJson
                      });
                    } else if (eventType === 'interactive') {
                      console.log('接收到 interactive 事件:', parseJson);
                      // 修复：正确处理 interactive 事件
                      responseQueue.push({
                        event: SseResponseEventEnum.interactive,
                        interactive: parseJson.interactive || parseJson  // 注意这里要提取 interactive 字段
                      });
                      isInteractive = true;
                      console.log('设置 isInteractive 为 true');
                    }
                  }
                }
              }
            }
          } catch (err) {
            if (err.name === 'AbortError') {
              finished = true;
              break;
            }
            console.error('读取流数据出错:', err);
            failedFinish(err);
            break;
          }
        }

        finished = true;

      } catch (err) {
        clearTimeout(timeoutId);

        if (abortCtrl.signal.aborted) {
          finished = true;
          return;
        }

        console.error('流式请求出错:', err);
        failedFinish(err);
      }
    })(); // 立即执行异步函数
  });
};

export default streamFetch;
